{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ungraded Lab - Trees Ensemble\n",
    "\n",
    "In this notebook, you will:\n",
    "\n",
    " - Use Pandas to perform one-hot encoding of a dataset\n",
    " - Use scikit-learn to implement a Decision Tree, Random Forest and XGBoost models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's import the libraries we will use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "from xgboost import XGBClassifier\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('./deeplearning.mplstyle')\n",
    "\n",
    "RANDOM_STATE = 55 ## We will pass it to every sklearn call so we ensure reproducibility"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Datatset\n",
    "- This dataset is obtained from Kaggle: [Heart Failure Prediction Dataset](https://www.kaggle.com/datasets/fedesoriano/heart-failure-prediction)\n",
    "\n",
    "#### Context\n",
    "- Cardiovascular disease (CVDs) is the number one cause of death globally, taking an estimated 17.9 million lives each year, which accounts for 31% of all deaths worldwide. Four out of five CVD deaths are due to heart attacks and strokes, and one-third of these deaths occur prematurely in people under 70 years of age. Heart failure is a common event caused by CVDs.\n",
    "- People with cardiovascular disease or who are at high cardiovascular risk (due to the presence of one or more risk factors such as hypertension, diabetes, hyperlipidaemia or already established disease) need early detection and management.  \n",
    "- This dataset contains 11 features that can be used to predict possible heart disease.\n",
    "- Let's train a machine learning model to assist with diagnosing this disease.\n",
    "\n",
    "#### Attribute Information\n",
    "- Age: age of the patient [years]\n",
    "- Sex: sex of the patient [M: Male, F: Female]\n",
    "- ChestPainType: chest pain type [TA: Typical Angina, ATA: Atypical Angina, NAP: Non-Anginal Pain, ASY: Asymptomatic]\n",
    "- RestingBP: resting blood pressure [mm Hg]\n",
    "- Cholesterol: serum cholesterol [mm/dl]\n",
    "- FastingBS: fasting blood sugar [1: if FastingBS > 120 mg/dl, 0: otherwise]\n",
    "- RestingECG: resting electrocardiogram results [Normal: Normal, ST: having ST-T wave abnormality (T wave inversions and/or ST elevation or depression of > 0.05 mV), LVH: showing probable or definite left ventricular hypertrophy by Estes' criteria]\n",
    "- MaxHR: maximum heart rate achieved [Numeric value between 60 and 202]\n",
    "- ExerciseAngina: exercise-induced angina [Y: Yes, N: No]\n",
    "- Oldpeak: oldpeak = ST [Numeric value measured in depression]\n",
    "- ST_Slope: the slope of the peak exercise ST segment [Up: upsloping, Flat: flat, Down: downsloping]\n",
    "- HeartDisease: output class [1: heart disease, 0: Normal]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's now load the dataset. As we can see above, the variables:\n",
    "\n",
    "- Sex\n",
    "- ChestPainType\n",
    "- RestingECG\n",
    "- ExerciseAngina\n",
    "- ST_Slope\n",
    "\n",
    "Are *categorical*, so we must one-hot encode them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the dataset using pandas\n",
    "df = pd.read_csv(\"heart.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Age</th>\n",
       "      <th>Sex</th>\n",
       "      <th>ChestPainType</th>\n",
       "      <th>RestingBP</th>\n",
       "      <th>Cholesterol</th>\n",
       "      <th>FastingBS</th>\n",
       "      <th>RestingECG</th>\n",
       "      <th>MaxHR</th>\n",
       "      <th>ExerciseAngina</th>\n",
       "      <th>Oldpeak</th>\n",
       "      <th>ST_Slope</th>\n",
       "      <th>HeartDisease</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>40</td>\n",
       "      <td>M</td>\n",
       "      <td>ATA</td>\n",
       "      <td>140</td>\n",
       "      <td>289</td>\n",
       "      <td>0</td>\n",
       "      <td>Normal</td>\n",
       "      <td>172</td>\n",
       "      <td>N</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Up</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>49</td>\n",
       "      <td>F</td>\n",
       "      <td>NAP</td>\n",
       "      <td>160</td>\n",
       "      <td>180</td>\n",
       "      <td>0</td>\n",
       "      <td>Normal</td>\n",
       "      <td>156</td>\n",
       "      <td>N</td>\n",
       "      <td>1.0</td>\n",
       "      <td>Flat</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>37</td>\n",
       "      <td>M</td>\n",
       "      <td>ATA</td>\n",
       "      <td>130</td>\n",
       "      <td>283</td>\n",
       "      <td>0</td>\n",
       "      <td>ST</td>\n",
       "      <td>98</td>\n",
       "      <td>N</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Up</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>48</td>\n",
       "      <td>F</td>\n",
       "      <td>ASY</td>\n",
       "      <td>138</td>\n",
       "      <td>214</td>\n",
       "      <td>0</td>\n",
       "      <td>Normal</td>\n",
       "      <td>108</td>\n",
       "      <td>Y</td>\n",
       "      <td>1.5</td>\n",
       "      <td>Flat</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>54</td>\n",
       "      <td>M</td>\n",
       "      <td>NAP</td>\n",
       "      <td>150</td>\n",
       "      <td>195</td>\n",
       "      <td>0</td>\n",
       "      <td>Normal</td>\n",
       "      <td>122</td>\n",
       "      <td>N</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Up</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Age Sex ChestPainType  RestingBP  Cholesterol  FastingBS RestingECG  MaxHR  \\\n",
       "0   40   M           ATA        140          289          0     Normal    172   \n",
       "1   49   F           NAP        160          180          0     Normal    156   \n",
       "2   37   M           ATA        130          283          0         ST     98   \n",
       "3   48   F           ASY        138          214          0     Normal    108   \n",
       "4   54   M           NAP        150          195          0     Normal    122   \n",
       "\n",
       "  ExerciseAngina  Oldpeak ST_Slope  HeartDisease  \n",
       "0              N      0.0       Up             0  \n",
       "1              N      1.0     Flat             1  \n",
       "2              N      0.0       Up             0  \n",
       "3              Y      1.5     Flat             1  \n",
       "4              N      0.0       Up             0  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We must perform some data engineering before working with the models. There are 5 categorical features, so we will use Pandas to one-hot encode them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. One-hot encoding using Pandas\n",
    "\n",
    "First we will remove the binary variables, because one-hot encoding them would do nothing to them. To achieve this we will just count how many different values there are in each categorical variable and consider only the variables with 3 or more values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "cat_variables = ['Sex',\n",
    "'ChestPainType',\n",
    "'RestingECG',\n",
    "'ExerciseAngina',\n",
    "'ST_Slope'\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a reminder, one-hot encoding aims to transform a categorical variable with `n` outputs into `n` binary variables.\n",
    "\n",
    "Pandas has a built-in method to one-hot encode variables, it is the function `pd.get_dummies`. There are several arguments to this function, but here we will use only a few. They are:\n",
    "\n",
    " - data: DataFrame to be used\n",
    " - prefix: A list with prefixes, so we know which value we are dealing with\n",
    " - columns: the list of columns that will be one-hot encoded. 'prefix' and 'columns' must have the same length.\n",
    " \n",
    "For more information, you can always type `help(pd.get_dummies)` to read the function's full documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This will replace the columns with the one-hot encoded ones and keep the columns outside 'columns' argument as it is.\n",
    "df = pd.get_dummies(data = df, prefix = cat_variables, columns = cat_variables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Age</th>\n",
       "      <th>RestingBP</th>\n",
       "      <th>Cholesterol</th>\n",
       "      <th>FastingBS</th>\n",
       "      <th>MaxHR</th>\n",
       "      <th>Oldpeak</th>\n",
       "      <th>HeartDisease</th>\n",
       "      <th>Sex_F</th>\n",
       "      <th>Sex_M</th>\n",
       "      <th>ChestPainType_ASY</th>\n",
       "      <th>...</th>\n",
       "      <th>ChestPainType_NAP</th>\n",
       "      <th>ChestPainType_TA</th>\n",
       "      <th>RestingECG_LVH</th>\n",
       "      <th>RestingECG_Normal</th>\n",
       "      <th>RestingECG_ST</th>\n",
       "      <th>ExerciseAngina_N</th>\n",
       "      <th>ExerciseAngina_Y</th>\n",
       "      <th>ST_Slope_Down</th>\n",
       "      <th>ST_Slope_Flat</th>\n",
       "      <th>ST_Slope_Up</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>40</td>\n",
       "      <td>140</td>\n",
       "      <td>289</td>\n",
       "      <td>0</td>\n",
       "      <td>172</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>...</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>49</td>\n",
       "      <td>160</td>\n",
       "      <td>180</td>\n",
       "      <td>0</td>\n",
       "      <td>156</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>...</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>37</td>\n",
       "      <td>130</td>\n",
       "      <td>283</td>\n",
       "      <td>0</td>\n",
       "      <td>98</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>...</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>48</td>\n",
       "      <td>138</td>\n",
       "      <td>214</td>\n",
       "      <td>0</td>\n",
       "      <td>108</td>\n",
       "      <td>1.5</td>\n",
       "      <td>1</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>...</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>54</td>\n",
       "      <td>150</td>\n",
       "      <td>195</td>\n",
       "      <td>0</td>\n",
       "      <td>122</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>...</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 21 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   Age  RestingBP  Cholesterol  FastingBS  MaxHR  Oldpeak  HeartDisease  \\\n",
       "0   40        140          289          0    172      0.0             0   \n",
       "1   49        160          180          0    156      1.0             1   \n",
       "2   37        130          283          0     98      0.0             0   \n",
       "3   48        138          214          0    108      1.5             1   \n",
       "4   54        150          195          0    122      0.0             0   \n",
       "\n",
       "   Sex_F  Sex_M  ChestPainType_ASY  ...  ChestPainType_NAP  ChestPainType_TA  \\\n",
       "0  False   True              False  ...              False             False   \n",
       "1   True  False              False  ...               True             False   \n",
       "2  False   True              False  ...              False             False   \n",
       "3   True  False               True  ...              False             False   \n",
       "4  False   True              False  ...               True             False   \n",
       "\n",
       "   RestingECG_LVH  RestingECG_Normal  RestingECG_ST  ExerciseAngina_N  \\\n",
       "0           False               True          False              True   \n",
       "1           False               True          False              True   \n",
       "2           False              False           True              True   \n",
       "3           False               True          False             False   \n",
       "4           False               True          False              True   \n",
       "\n",
       "   ExerciseAngina_Y  ST_Slope_Down  ST_Slope_Flat  ST_Slope_Up  \n",
       "0             False          False          False         True  \n",
       "1             False          False           True        False  \n",
       "2             False          False          False         True  \n",
       "3              True          False           True        False  \n",
       "4             False          False          False         True  \n",
       "\n",
       "[5 rows x 21 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's choose the variables that will be the input features of the model.\n",
    "- The target is `HeartDisease`.\n",
    "- All other variables are features that can potentially be used to predict the target, `HeartDisease`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = [x for x in df.columns if x not in 'HeartDisease'] ## Removing our target variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We started with 11 features.  Let's see how many feature variables we have after one-hot encoding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "print(len(features))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Splitting the Dataset\n",
    "\n",
    "In this section, we will split our dataset into train and test datasets. We will use the function `train_test_split` from Scikit-learn. Let's just check its arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function train_test_split in module sklearn.model_selection._split:\n",
      "\n",
      "train_test_split(*arrays, test_size=None, train_size=None, random_state=None, shuffle=True, stratify=None)\n",
      "    Split arrays or matrices into random train and test subsets.\n",
      "    \n",
      "    Quick utility that wraps input validation,\n",
      "    ``next(ShuffleSplit().split(X, y))``, and application to input data\n",
      "    into a single call for splitting (and optionally subsampling) data into a\n",
      "    one-liner.\n",
      "    \n",
      "    Read more in the :ref:`User Guide <cross_validation>`.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    *arrays : sequence of indexables with same length / shape[0]\n",
      "        Allowed inputs are lists, numpy arrays, scipy-sparse\n",
      "        matrices or pandas dataframes.\n",
      "    \n",
      "    test_size : float or int, default=None\n",
      "        If float, should be between 0.0 and 1.0 and represent the proportion\n",
      "        of the dataset to include in the test split. If int, represents the\n",
      "        absolute number of test samples. If None, the value is set to the\n",
      "        complement of the train size. If ``train_size`` is also None, it will\n",
      "        be set to 0.25.\n",
      "    \n",
      "    train_size : float or int, default=None\n",
      "        If float, should be between 0.0 and 1.0 and represent the\n",
      "        proportion of the dataset to include in the train split. If\n",
      "        int, represents the absolute number of train samples. If None,\n",
      "        the value is automatically set to the complement of the test size.\n",
      "    \n",
      "    random_state : int, RandomState instance or None, default=None\n",
      "        Controls the shuffling applied to the data before applying the split.\n",
      "        Pass an int for reproducible output across multiple function calls.\n",
      "        See :term:`Glossary <random_state>`.\n",
      "    \n",
      "    shuffle : bool, default=True\n",
      "        Whether or not to shuffle the data before splitting. If shuffle=False\n",
      "        then stratify must be None.\n",
      "    \n",
      "    stratify : array-like, default=None\n",
      "        If not None, data is split in a stratified fashion, using this as\n",
      "        the class labels.\n",
      "        Read more in the :ref:`User Guide <stratification>`.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    splitting : list, length=2 * len(arrays)\n",
      "        List containing train-test split of inputs.\n",
      "    \n",
      "        .. versionadded:: 0.16\n",
      "            If the input is sparse, the output will be a\n",
      "            ``scipy.sparse.csr_matrix``. Else, output type is the same as the\n",
      "            input type.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> import numpy as np\n",
      "    >>> from sklearn.model_selection import train_test_split\n",
      "    >>> X, y = np.arange(10).reshape((5, 2)), range(5)\n",
      "    >>> X\n",
      "    array([[0, 1],\n",
      "           [2, 3],\n",
      "           [4, 5],\n",
      "           [6, 7],\n",
      "           [8, 9]])\n",
      "    >>> list(y)\n",
      "    [0, 1, 2, 3, 4]\n",
      "    \n",
      "    >>> X_train, X_test, y_train, y_test = train_test_split(\n",
      "    ...     X, y, test_size=0.33, random_state=42)\n",
      "    ...\n",
      "    >>> X_train\n",
      "    array([[4, 5],\n",
      "           [0, 1],\n",
      "           [6, 7]])\n",
      "    >>> y_train\n",
      "    [2, 0, 3]\n",
      "    >>> X_test\n",
      "    array([[2, 3],\n",
      "           [8, 9]])\n",
      "    >>> y_test\n",
      "    [1, 4]\n",
      "    \n",
      "    >>> train_test_split(y, shuffle=False)\n",
      "    [[0, 1, 2], [3, 4]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(train_test_split)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_val, y_train, y_val = train_test_split(df[features], df['HeartDisease'], train_size = 0.8, random_state = RANDOM_STATE)\n",
    "\n",
    "# We will keep the shuffle = True since our dataset has not any time dependency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train samples: 734 validation samples: 184\n",
      "target proportion: 0.5518\n"
     ]
    }
   ],
   "source": [
    "print(f'train samples: {len(X_train)} validation samples: {len(X_val)}')\n",
    "print(f'target proportion: {sum(y_train)/len(y_train):.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Building the Models\n",
    "\n",
    "## 4.1 Decision Tree\n",
    "\n",
    "In this section, let's work with the Decision Tree we previously learned, but now using the [Scikit-learn implementation](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html). \n",
    "\n",
    "There are several hyperparameters in the Decision Tree object from Scikit-learn. We will use only some of them and also we will not perform feature selection nor hyperparameter tuning in this lab (but you are encouraged to do so and compare the results 😄 )\n",
    "\n",
    "The hyperparameters we will use and investigate here are:\n",
    "\n",
    " - min_samples_split: The minimum number of samples required to split an internal node. \n",
    "   - Choosing a higher min_samples_split can reduce the number of splits and may help to reduce overfitting.\n",
    " - max_depth: The maximum depth of the tree. \n",
    "   - Choosing a lower max_depth can reduce the number of splits and may help to reduce overfitting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "min_samples_split_list = [2,10, 30, 50, 100, 200, 300, 700] ## If the number is an integer, then it is the actual quantity of samples,\n",
    "max_depth_list = [1,2, 3, 4, 8, 16, 32, 64, None] # None means that there is no depth limit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x20368a29480>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracy_list_train = []\n",
    "accuracy_list_val = []\n",
    "for min_samples_split in min_samples_split_list:\n",
    "    # You can fit the model at the same time you define it, because the fit function returns the fitted estimator.\n",
    "    model = DecisionTreeClassifier(min_samples_split = min_samples_split,\n",
    "                                   random_state = RANDOM_STATE).fit(X_train,y_train) \n",
    "    predictions_train = model.predict(X_train) ## The predicted values for the train dataset\n",
    "    predictions_val = model.predict(X_val) ## The predicted values for the test dataset\n",
    "    accuracy_train = accuracy_score(predictions_train,y_train)\n",
    "    accuracy_val = accuracy_score(predictions_val,y_val)\n",
    "    accuracy_list_train.append(accuracy_train)\n",
    "    accuracy_list_val.append(accuracy_val)\n",
    "\n",
    "plt.title('Train x Validation metrics')\n",
    "plt.xlabel('min_samples_split')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xticks(ticks = range(len(min_samples_split_list )),labels=min_samples_split_list)\n",
    "plt.plot(accuracy_list_train)\n",
    "plt.plot(accuracy_list_val)\n",
    "plt.legend(['Train','Validation'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how increasing the the number of `min_samples_split` reduces overfitting.\n",
    "- Increasing `min_samples_split` from 10 to 30, and from 30 to 50, even though it does not improve the validation accuracy, it brings the training accuracy closer to it, showing a reduction in overfitting.\n",
    "\n",
    "Let's do the same experiment with `max_depth`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2036ac65810>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracy_list_train = []\n",
    "accuracy_list_val = []\n",
    "for max_depth in max_depth_list:\n",
    "    # You can fit the model at the same time you define it, because the fit function returns the fitted estimator.\n",
    "    model = DecisionTreeClassifier(max_depth = max_depth,\n",
    "                                   random_state = RANDOM_STATE).fit(X_train,y_train) \n",
    "    predictions_train = model.predict(X_train) ## The predicted values for the train dataset\n",
    "    predictions_val = model.predict(X_val) ## The predicted values for the test dataset\n",
    "    accuracy_train = accuracy_score(predictions_train,y_train)\n",
    "    accuracy_val = accuracy_score(predictions_val,y_val)\n",
    "    accuracy_list_train.append(accuracy_train)\n",
    "    accuracy_list_val.append(accuracy_val)\n",
    "\n",
    "plt.title('Train x Validation metrics')\n",
    "plt.xlabel('max_depth')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xticks(ticks = range(len(max_depth_list )),labels=max_depth_list)\n",
    "plt.plot(accuracy_list_train)\n",
    "plt.plot(accuracy_list_val)\n",
    "plt.legend(['Train','Validation'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that in general, reducing `max_depth` can help to reduce overfitting.\n",
    "- Reducing `max_depth` from 8 to 4 increases validation accuracy closer to training accuracy, while significantly reducing training accuracy.\n",
    "- The validation accuracy reaches the highest at tree_depth=4. \n",
    "- When the `max_depth` is smaller than 3, both training and validation accuracy decreases.  The tree cannot make enough splits to distinguish positives from negatives (the model is underfitting the training set). \n",
    "- When the `max_depth` is too high ( >= 5), validation accuracy decreases while training accuracy increases, indicating that the model is overfitting to the training set.\n",
    "\n",
    "So we can choose the best values for these two hyper-parameters for our model to be:\n",
    "- `max_depth = 4`\n",
    "- `min_samples_split = 50` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "decision_tree_model = DecisionTreeClassifier(min_samples_split = 50,\n",
    "                                             max_depth = 3,\n",
    "                                             random_state = RANDOM_STATE).fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metrics train:\n",
      "\tAccuracy score: 0.8583\n",
      "Metrics validation:\n",
      "\tAccuracy score: 0.8641\n"
     ]
    }
   ],
   "source": [
    "print(f\"Metrics train:\\n\\tAccuracy score: {accuracy_score(decision_tree_model.predict(X_train),y_train):.4f}\")\n",
    "print(f\"Metrics validation:\\n\\tAccuracy score: {accuracy_score(decision_tree_model.predict(X_val),y_val):.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No sign of overfitting, even though the metrics are not that good."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 Random Forest\n",
    "\n",
    "Now let's try the Random Forest algorithm also, using the Scikit-learn implementation. \n",
    "- All of the hyperparameters found in the decision tree model will also exist in this algorithm, since a random forest is an ensemble of many Decision Trees.\n",
    "- One additional hyperparameter for Random Forest is called `n_estimators` which is the number of Decision Trees that make up the Random Forest. \n",
    "\n",
    "Remember that for a Random Forest, we randomly choose a subset of the features AND randomly choose a subset of the training examples to train each individual tree.\n",
    "- Following the lectures, if $n$ is the number of features, we will randomly select $\\sqrt{n}$ of these features to train each individual tree. \n",
    "- Note that you can modify this by setting the `max_features` parameter.\n",
    "\n",
    "You can also speed up your training jobs with another parameter, `n_jobs`. \n",
    "- Since the fitting of each tree is independent of each other, it is possible fit more than one tree in parallel. \n",
    "- So setting `n_jobs` higher will increase how many CPU cores it will use. Note that the numbers very close to the maximum cores of your CPU may impact on the overall performance of your PC and even lead to freezes. \n",
    "- Changing this parameter does not impact on the final result but can reduce the training time.\n",
    "\n",
    "We will run the same script again, but with another parameter, `n_estimators`, where we will choose between 10, 50, and 100. The default is 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "min_samples_split_list = [2,10, 30, 50, 100, 200, 300, 700]  ## If the number is an integer, then it is the actual quantity of samples,\n",
    "                                             ## If it is a float, then it is the percentage of the dataset\n",
    "max_depth_list = [2, 4, 8, 16, 32, 64, None]\n",
    "n_estimators_list = [10,50,100,500]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2036ace76a0>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracy_list_train = []\n",
    "accuracy_list_val = []\n",
    "for min_samples_split in min_samples_split_list:\n",
    "    # You can fit the model at the same time you define it, because the fit function returns the fitted estimator.\n",
    "    model = RandomForestClassifier(min_samples_split = min_samples_split,\n",
    "                                   random_state = RANDOM_STATE).fit(X_train,y_train) \n",
    "    predictions_train = model.predict(X_train) ## The predicted values for the train dataset\n",
    "    predictions_val = model.predict(X_val) ## The predicted values for the test dataset\n",
    "    accuracy_train = accuracy_score(predictions_train,y_train)\n",
    "    accuracy_val = accuracy_score(predictions_val,y_val)\n",
    "    accuracy_list_train.append(accuracy_train)\n",
    "    accuracy_list_val.append(accuracy_val)\n",
    "\n",
    "plt.title('Train x Validation metrics')\n",
    "plt.xlabel('min_samples_split')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xticks(ticks = range(len(min_samples_split_list )),labels=min_samples_split_list) \n",
    "plt.plot(accuracy_list_train)\n",
    "plt.plot(accuracy_list_val)\n",
    "plt.legend(['Train','Validation'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that, even though the validation accuraty reaches is the same both at `min_samples_split = 2` and `min_samples_split = 10`, in the latter the difference in training and validation set reduces, showing less overfitting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x20368b5bca0>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracy_list_train = []\n",
    "accuracy_list_val = []\n",
    "for max_depth in max_depth_list:\n",
    "    # You can fit the model at the same time you define it, because the fit function returns the fitted estimator.\n",
    "    model = RandomForestClassifier(max_depth = max_depth,\n",
    "                                   random_state = RANDOM_STATE).fit(X_train,y_train) \n",
    "    predictions_train = model.predict(X_train) ## The predicted values for the train dataset\n",
    "    predictions_val = model.predict(X_val) ## The predicted values for the test dataset\n",
    "    accuracy_train = accuracy_score(predictions_train,y_train)\n",
    "    accuracy_val = accuracy_score(predictions_val,y_val)\n",
    "    accuracy_list_train.append(accuracy_train)\n",
    "    accuracy_list_val.append(accuracy_val)\n",
    "\n",
    "plt.title('Train x Validation metrics')\n",
    "plt.xlabel('max_depth')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xticks(ticks = range(len(max_depth_list )),labels=max_depth_list)\n",
    "plt.plot(accuracy_list_train)\n",
    "plt.plot(accuracy_list_val)\n",
    "plt.legend(['Train','Validation'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x20368beb430>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracy_list_train = []\n",
    "accuracy_list_val = []\n",
    "for n_estimators in n_estimators_list:\n",
    "    # You can fit the model at the same time you define it, because the fit function returns the fitted estimator.\n",
    "    model = RandomForestClassifier(n_estimators = n_estimators,\n",
    "                                   random_state = RANDOM_STATE).fit(X_train,y_train) \n",
    "    predictions_train = model.predict(X_train) ## The predicted values for the train dataset\n",
    "    predictions_val = model.predict(X_val) ## The predicted values for the test dataset\n",
    "    accuracy_train = accuracy_score(predictions_train,y_train)\n",
    "    accuracy_val = accuracy_score(predictions_val,y_val)\n",
    "    accuracy_list_train.append(accuracy_train)\n",
    "    accuracy_list_val.append(accuracy_val)\n",
    "\n",
    "plt.title('Train x Validation metrics')\n",
    "plt.xlabel('n_estimators')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xticks(ticks = range(len(n_estimators_list )),labels=n_estimators_list)\n",
    "plt.plot(accuracy_list_train)\n",
    "plt.plot(accuracy_list_val)\n",
    "plt.legend(['Train','Validation'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's then fit a random forest with the following parameters:\n",
    "\n",
    " - max_depth: 16\n",
    " - min_samples_split: 10\n",
    " - n_estimators: 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_forest_model = RandomForestClassifier(n_estimators = 100,\n",
    "                                             max_depth = 16, \n",
    "                                             min_samples_split = 10).fit(X_train,y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metrics train:\n",
      "\tAccuracy score: 0.9278\n",
      "Metrics test:\n",
      "\tAccuracy score: 0.8859\n"
     ]
    }
   ],
   "source": [
    "print(f\"Metrics train:\\n\\tAccuracy score: {accuracy_score(random_forest_model.predict(X_train),y_train):.4f}\\nMetrics test:\\n\\tAccuracy score: {accuracy_score(random_forest_model.predict(X_val),y_val):.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we are searching for the best value one hyperparameter while leaving the other hyperparameters at their default values.\n",
    "- Ideally, we would want to check every combination of values for every hyperparameter that we are tuning.\n",
    "- If we have 3 hyperparameters, and each hyperparameter has 4 values to try out, we should have a total of 4 x 4 x 4 = 64 combinations to try.\n",
    "- When we only modify one hyperparameter while leaving the rest as their default value, we are trying 4 + 4 + 4 = 12 results. \n",
    "- To try out all combinations, we can use a sklearn implementation called GridSearchCV. GridSearchCV has a refit parameter that will automatically refit a model on the best combination so we will not need to program it explicitly. For more on GridSearchCV, please refer to its [documentation](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.3 XGBoost\n",
    "\n",
    "Next is the Gradient Boosting model, called XGBoost. The boosting methods train several trees, but instead of them being uncorrelated to each other, now the trees are fit one after the other in order to minimize the error. \n",
    "\n",
    "The model has the same parameters as a decision tree, plus the learning rate.\n",
    "- The learning rate is the size of the step on the Gradient Descent method that the XGBoost uses internally to minimize the error on each train step.\n",
    "\n",
    "One interesting thing about the XGBoost is that during fitting, it can take in an evaluation dataset of the form `(X_val,y_val)`.\n",
    "- On each iteration, it measures the cost (or evaluation metric) on the evaluation datasets.\n",
    "- Once the cost (or metric) stops decreasing for a number of rounds (called early_stopping_rounds), the training will stop. \n",
    "- More iterations lead to more estimators, and more estimators can result in overfitting.  \n",
    "- By stopping once the validation metric no longer improves, we can limit the number of estimators created, and reduce overfitting.\n",
    "\n",
    "First, let's define a subset of our training set (we should not use the test set here)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(len(X_train)*0.8) ## Let's use 80% to train and 20% to eval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_fit, X_train_eval, y_train_fit, y_train_eval = X_train[:n], X_train[n:], y_train[:n], y_train[n:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then set a large number of estimators, because we can stop if the cost function stops decreasing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note some of the `.fit()` parameters:\n",
    "- `eval_set = [(X_train_eval,y_train_eval)]`:Here we must pass a list to the eval_set, because you can have several different tuples ov eval sets. \n",
    "- `early_stopping_rounds`: This parameter helps to stop the model training if its evaluation metric is no longer improving on the validation set. It's set to 10.\n",
    "  - The model keeps track of the round with the best performance (lowest evaluation metric).  For example, let's say round 16 has the lowest evaluation metric so far.\n",
    "  - Each successive round's evaluation metric is compared to the best metric.  If the model goes 10 rounds where none have a better metric than the best one, then the model stops training.\n",
    "  - The model is returned at its last state when training terminated, not its state during the best round.  For example, if the model stops at round 26, but the best round was 16, the model's training state at round 26 is returned, not round 16.\n",
    "  - Note that this is different from returning the model's \"best\" state (from when the evaluation metric was the lowest)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0]\tvalidation_0-logloss:0.63302\n",
      "[1]\tvalidation_0-logloss:0.59554\n",
      "[2]\tvalidation_0-logloss:0.56614\n",
      "[3]\tvalidation_0-logloss:0.54187\n",
      "[4]\tvalidation_0-logloss:0.52349\n",
      "[5]\tvalidation_0-logloss:0.50611\n",
      "[6]\tvalidation_0-logloss:0.49373\n",
      "[7]\tvalidation_0-logloss:0.48366\n",
      "[8]\tvalidation_0-logloss:0.47323\n",
      "[9]\tvalidation_0-logloss:0.46538\n",
      "[10]\tvalidation_0-logloss:0.46000\n",
      "[11]\tvalidation_0-logloss:0.45621\n",
      "[12]\tvalidation_0-logloss:0.45483\n",
      "[13]\tvalidation_0-logloss:0.44975\n",
      "[14]\tvalidation_0-logloss:0.44495\n",
      "[15]\tvalidation_0-logloss:0.44073\n",
      "[16]\tvalidation_0-logloss:0.44078\n",
      "[17]\tvalidation_0-logloss:0.43936\n",
      "[18]\tvalidation_0-logloss:0.44206\n",
      "[19]\tvalidation_0-logloss:0.44536\n",
      "[20]\tvalidation_0-logloss:0.44322\n",
      "[21]\tvalidation_0-logloss:0.44310\n",
      "[22]\tvalidation_0-logloss:0.44419\n",
      "[23]\tvalidation_0-logloss:0.44797\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\TA\\machine-learning-specialization-coursera\\.venv\\lib\\site-packages\\xgboost\\sklearn.py:885: UserWarning: `early_stopping_rounds` in `fit` method is deprecated for better compatibility with scikit-learn, use `early_stopping_rounds` in constructor or`set_params` instead.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[24]\tvalidation_0-logloss:0.44843\n",
      "[25]\tvalidation_0-logloss:0.45337\n",
      "[26]\tvalidation_0-logloss:0.45206\n",
      "[27]\tvalidation_0-logloss:0.45435\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
       "              colsample_bylevel=None, colsample_bynode=None,\n",
       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
       "              gamma=None, grow_policy=None, importance_type=None,\n",
       "              interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
       "              multi_strategy=None, n_estimators=500, n_jobs=None,\n",
       "              num_parallel_tree=None, random_state=55, ...)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">XGBClassifier</label><div class=\"sk-toggleable__content\"><pre>XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
       "              colsample_bylevel=None, colsample_bynode=None,\n",
       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
       "              gamma=None, grow_policy=None, importance_type=None,\n",
       "              interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
       "              multi_strategy=None, n_estimators=500, n_jobs=None,\n",
       "              num_parallel_tree=None, random_state=55, ...)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
       "              colsample_bylevel=None, colsample_bynode=None,\n",
       "              colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
       "              enable_categorical=False, eval_metric=None, feature_types=None,\n",
       "              gamma=None, grow_policy=None, importance_type=None,\n",
       "              interaction_constraints=None, learning_rate=0.1, max_bin=None,\n",
       "              max_cat_threshold=None, max_cat_to_onehot=None,\n",
       "              max_delta_step=None, max_depth=None, max_leaves=None,\n",
       "              min_child_weight=None, missing=nan, monotone_constraints=None,\n",
       "              multi_strategy=None, n_estimators=500, n_jobs=None,\n",
       "              num_parallel_tree=None, random_state=55, ...)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xgb_model = XGBClassifier(n_estimators = 500, learning_rate = 0.1,verbosity = 1, random_state = RANDOM_STATE)\n",
    "xgb_model.fit(X_train_fit,y_train_fit, eval_set = [(X_train_eval,y_train_eval)], early_stopping_rounds = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though we initialized the model to allow up to 500 estimators, the algorithm only fit 26 estimators (over 26 rounds of training).\n",
    "\n",
    "To see why, let's look for the round of training that had the best performance (lowest evaluation metric).  You can either view the validation log loss metrics that were output above, or view the model's `.best_iteration` attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xgb_model.best_iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The best round of training was round 16, with a log loss of 4.3948.  \n",
    "- For 10 rounds of training after that (from round 17 to 26), the log loss was higher than this.\n",
    "- Since we set `early_stopping_rounds` to 10, then by the 10th round where the log loss doesn't improve upon the best one, training stops.\n",
    "- You can try out different values of `early_stopping_rounds` to verify this.  If you set it to 20, for instance, the model stops training at round 36 (16 + 20)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metrics train:\n",
      "\tAccuracy score: 0.9319\n",
      "Metrics test:\n",
      "\tAccuracy score: 0.8533\n"
     ]
    }
   ],
   "source": [
    "print(f\"Metrics train:\\n\\tAccuracy score: {accuracy_score(xgb_model.predict(X_train),y_train):.4f}\\nMetrics test:\\n\\tAccuracy score: {accuracy_score(xgb_model.predict(X_val),y_val):.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, both Random Forest and XGBoost had similar performance (test accuracy).  \n",
    "\n",
    "Congratulations, you have learned how to use Decision Tree, Random Forest from the scikit-learn library and XGBoost!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb064499",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  },
  "vscode": {
   "interpreter": {
    "hash": "56d44d6a8424451b5ce45d1ae0b0b7865dc60710e7f74571dd51dd80d7829ee9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
